{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "a8HQYsAtC0Fv",
    "tags": []
   },
   "source": [
    "# Classifying Images using Dropout and Batchnorm Layer\n",
    "\n",
    "## Introduction\n",
    "\n",
    "In this notebook, you learn how to build a neural network to classify the tf-flowers dataset using dropout and batchnorm layer.\n",
    "\n",
    "## Learning objectives\n",
    "\n",
    "* Define Helper Functions.\n",
    "* Apply dropout and batchnorm layer.\n",
    "\n",
    "\n",
    "Each learning objective will correspond to a __#TODO__ in the [student lab notebook](../labs/classifying_images_using_dropout_and_batchnorm_layer.ipynb) -- try to complete that notebook first before reviewing this solution notebook.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ugGJcxKAwhc2",
    "outputId": "f25e3267-1495-48f8-d6e1-4da24dd41755",
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.6.0\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "print(tf.version.VERSION)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define Helper Functions\n",
    "#### Reading and Preprocessing image data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "LKXV5oRmkSTK"
   },
   "outputs": [],
   "source": [
    "# Helper functions\n",
    "def training_plot(metrics, history):\n",
    "  f, ax = plt.subplots(1, len(metrics), figsize=(5*len(metrics), 5))\n",
    "  for idx, metric in enumerate(metrics):\n",
    "    ax[idx].plot(history.history[metric], ls='dashed')\n",
    "    ax[idx].set_xlabel(\"Epochs\")\n",
    "    ax[idx].set_ylabel(metric)\n",
    "    ax[idx].plot(history.history['val_' + metric]);\n",
    "    ax[idx].legend([metric, 'val_' + metric])\n",
    "\n",
    "# Call model.predict() on a few images in the evaluation dataset\n",
    "def plot_predictions(filename):\n",
    "  f, ax = plt.subplots(3, 5, figsize=(25,15))\n",
    "  dataset = (tf.data.TextLineDataset(filename).\n",
    "      map(decode_csv))\n",
    "  for idx, (img, label) in enumerate(dataset.take(15)):\n",
    "    ax[idx//5, idx%5].imshow((img.numpy()));\n",
    "    batch_image = tf.reshape(img, [1, IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS])\n",
    "    batch_pred = model.predict(batch_image)\n",
    "    pred = batch_pred[0]\n",
    "    label = CLASS_NAMES[label.numpy()]\n",
    "    pred_label_index = tf.math.argmax(pred).numpy()\n",
    "    pred_label = CLASS_NAMES[pred_label_index]\n",
    "    prob = pred[pred_label_index]\n",
    "    ax[idx//5, idx%5].set_title('{}: {} ({:.4f})'.format(label, pred_label, prob))\n",
    "\n",
    "def show_trained_weights(model):\n",
    "  # CLASS_NAMES is ['daisy', 'dandelion', 'roses', 'sunflowers', 'tulips']\n",
    "  LAYER = 1 # Layer 0 flattens the image, layer=1 is the first dense layer\n",
    "  WEIGHT_TYPE = 0 # 0 for weight, 1 for bias\n",
    "\n",
    "  f, ax = plt.subplots(1, 5, figsize=(15,15))\n",
    "  for flower in range(len(CLASS_NAMES)):\n",
    "    weights = model.layers[LAYER].get_weights()[WEIGHT_TYPE][:, flower]\n",
    "    min_wt = tf.math.reduce_min(weights).numpy()\n",
    "    max_wt = tf.math.reduce_max(weights).numpy()\n",
    "    flower_name = CLASS_NAMES[flower]\n",
    "    print(\"Scaling weights for {} in {} to {}\".format(\n",
    "        flower_name, min_wt, max_wt))\n",
    "    weights = (weights - min_wt)/(max_wt - min_wt)\n",
    "    ax[flower].imshow(weights.reshape(IMG_HEIGHT, IMG_WIDTH, 3));\n",
    "    ax[flower].set_title(flower_name);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ATwrq3yQXCZ3",
    "outputId": "211a7575-abf1-44a4-c15c-2d264d885f99"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "These are the available classes: ['daisy', 'dandelion', 'roses', 'sunflowers', 'tulips']\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-11-16 18:23:43.413262: I tensorflow/core/common_runtime/process_util.cc:146] Creating new thread pool with default inter op setting: 2. Tune using inter_op_parallelism_threads for best performance.\n"
     ]
    }
   ],
   "source": [
    "import matplotlib.pylab as plt\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "IMG_HEIGHT = 224\n",
    "IMG_WIDTH = 224\n",
    "IMG_CHANNELS = 3\n",
    "\n",
    "def read_and_decode(filename, reshape_dims):\n",
    "  # Read the file\n",
    "  img = tf.io.read_file(filename)\n",
    "  # Convert the compressed string to a 3D uint8 tensor.\n",
    "  img = tf.image.decode_jpeg(img, channels=IMG_CHANNELS)\n",
    "  # Use `convert_image_dtype` to convert to floats in the [0,1] range.\n",
    "  img = tf.image.convert_image_dtype(img, tf.float32)\n",
    "\n",
    "  # TODO 1: Resize the image to the desired size.\n",
    "  return tf.image.resize(img, reshape_dims)\n",
    "\n",
    "CLASS_NAMES = [item.numpy().decode(\"utf-8\") for item in \n",
    "               tf.strings.regex_replace(\n",
    "                 tf.io.gfile.glob(\"gs://cloud-training-demos/practical-ml-vision-book-data/flowers_5_jpeg/flower_photos/*\"),\n",
    "                 \"gs://cloud-training-demos/practical-ml-vision-book-data/flowers_5_jpeg/flower_photos/\", \"\")]\n",
    "CLASS_NAMES = [item for item in CLASS_NAMES if item.find(\".\") == -1]\n",
    "print(\"These are the available classes:\", CLASS_NAMES)\n",
    "\n",
    "# the label is the index into CLASS_NAMES array\n",
    "def decode_csv(csv_row):\n",
    "  record_defaults = [\"path\", \"flower\"]\n",
    "  filename, label_string = tf.io.decode_csv(csv_row, record_defaults)\n",
    "  img = read_and_decode(filename, [IMG_HEIGHT, IMG_WIDTH])\n",
    "  label = tf.argmax(tf.math.equal(CLASS_NAMES, label_string))\n",
    "  return img, label"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Duu8mX3iXANE",
    "tags": []
   },
   "source": [
    "## Apply dropout and batchnorm layer\n",
    "A deep neural network (DNN) is a neural network with more than one hidden layer. Each time you add a layer, the number of trainable parameters increases. Therefore,you need a larger dataset. You still have only 3700 flower images which might cause overfitting.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dropouts are the regularization technique that is used to prevent overfitting in the model. Batch normalization is a layer that allows every layer of the network to do learning more independently. The layer is added to the sequential model to standardize the input or the outputs. Add a dropout and batchnorm layer after each of the hidden layers.\n",
    "\n",
    "#### Dropout\n",
    "Dropout is one of the oldest regularization techniques in deep learning. At each training iteration, it drops random neurons from the network with a probability p (typically 25% to 50%). In practice, neuron outputs are set to 0. The net result is that these neurons will not participate in the loss computation this time around and they will not get weight updates. Different neurons will be dropped at each training iteration.\n",
    "#### Batch normalization\n",
    "Our input pixel values are in the range [0,1] and this is compatible with the dynamic range of the typical activation functions and optimizers. However, once we add a hidden layer, the resulting output values will no longer lie in the dynamic range of the activation function for subsequent layers. When this happens, the neuron output is zero, and because there is no difference by moving a small amount in either direction, the gradient is zero. There is no way for the network to escape from the dead zone. To fix this, batch norm normalizes neuron outputs across a training batch of data, i.e. it subtracts the average and divides by the standard deviation. This way, the network decides, through machine learning, how much centering and re-scaling to apply at each neuron. In Keras, you can selectively use one or the other:\n",
    "\n",
    "`tf.keras.layers.BatchNormalization(scale=False, center=True)`\n",
    "\n",
    "When using batch normalization, remember that:\n",
    "1. Batch normalization goes between the output of a layer and its activation function. So, rather than set activation='relu' in the Dense layer’s constructor, we’d omit the activation function, and then add a separate Activation layer.\n",
    "2. If you use center=True in batch norm, you do not need biases in your layer. The batch norm offset plays the role of a bias.\n",
    "3. If you use an activation function that is scale-invariant (i.e. does not change shape if you zoom in on it) then you can set scale=False. ReLu is scale-invariant. Sigmoid is not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "7OxxAryMXH1k"
   },
   "outputs": [],
   "source": [
    "def train_and_evaluate(batch_size = 32,\n",
    "                       lrate = 0.0001,\n",
    "                       l1 = 0,\n",
    "                       l2 = 0.001,\n",
    "                       dropout_prob = 0.4,\n",
    "                       num_hidden = [64, 16]):\n",
    "  regularizer = tf.keras.regularizers.l1_l2(l1, l2)\n",
    "\n",
    "  train_dataset = (tf.data.TextLineDataset(\n",
    "      \"gs://cloud-training-demos/practical-ml-vision-book-data/flowers_5_jpeg/flower_photos/train_set.csv\").\n",
    "      map(decode_csv)).batch(batch_size)\n",
    "\n",
    "  eval_dataset = (tf.data.TextLineDataset(\n",
    "      \"gs://cloud-training-demos/practical-ml-vision-book-data/flowers_5_jpeg/flower_photos/eval_set.csv\").\n",
    "      map(decode_csv)).batch(32) # this doesn't matter\n",
    "\n",
    "  # NN with multiple hidden layers\n",
    "  layers = [tf.keras.layers.Flatten(\n",
    "      input_shape=(IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS),\n",
    "      name='input_pixels')]\n",
    "  for hno, nodes in enumerate(num_hidden):\n",
    "    layers.extend([\n",
    "      tf.keras.layers.Dense(nodes,\n",
    "                            kernel_regularizer=regularizer, \n",
    "                            name='hidden_dense_{}'.format(hno)),\n",
    "      tf.keras.layers.BatchNormalization(scale=False, # ReLU\n",
    "                                         center=False, # have bias in Dense\n",
    "                                         name='batchnorm_dense_{}'.format(hno)),\n",
    "      #move activation to come after batchnorm\n",
    "      tf.keras.layers.Activation('relu', name='relu_dense_{}'.format(hno)),\n",
    "\n",
    "  # TODO 2: Apply Dropout to the input\n",
    "      tf.keras.layers.Dropout(rate=dropout_prob,\n",
    "                             name='dropout_dense_{}'.format(hno)),                         \n",
    "    ])\n",
    "\n",
    "  layers.append(\n",
    "      tf.keras.layers.Dense(len(CLASS_NAMES), \n",
    "                            kernel_regularizer=regularizer,\n",
    "                            activation='softmax',\n",
    "                            name='flower_prob')\n",
    "  )\n",
    "\n",
    "  model = tf.keras.Sequential(layers, name='flower_classification')\n",
    "  model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=lrate),\n",
    "                loss=tf.keras.losses.SparseCategoricalCrossentropy(\n",
    "                    from_logits=False),\n",
    "                metrics=['accuracy'])\n",
    "  print(model.summary())\n",
    "  history = model.fit(train_dataset, validation_data=eval_dataset, epochs=10)\n",
    "  training_plot(['loss', 'accuracy'], history)\n",
    "  return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "id": "nNDruEBPXPLD",
    "outputId": "94ad4651-894e-4646-a901-92ae7419fea7"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"flower_classification\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "input_pixels (Flatten)       (None, 150528)            0         \n",
      "_________________________________________________________________\n",
      "hidden_dense_0 (Dense)       (None, 64)                9633856   \n",
      "_________________________________________________________________\n",
      "batchnorm_dense_0 (BatchNorm (None, 64)                128       \n",
      "_________________________________________________________________\n",
      "relu_dense_0 (Activation)    (None, 64)                0         \n",
      "_________________________________________________________________\n",
      "dropout_dense_0 (Dropout)    (None, 64)                0         \n",
      "_________________________________________________________________\n",
      "hidden_dense_1 (Dense)       (None, 16)                1040      \n",
      "_________________________________________________________________\n",
      "batchnorm_dense_1 (BatchNorm (None, 16)                32        \n",
      "_________________________________________________________________\n",
      "relu_dense_1 (Activation)    (None, 16)                0         \n",
      "_________________________________________________________________\n",
      "dropout_dense_1 (Dropout)    (None, 16)                0         \n",
      "_________________________________________________________________\n",
      "flower_prob (Dense)          (None, 5)                 85        \n",
      "=================================================================\n",
      "Total params: 9,635,141\n",
      "Trainable params: 9,634,981\n",
      "Non-trainable params: 160\n",
      "_________________________________________________________________\n",
      "None\n",
      "Epoch 1/10\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2021-11-16 18:25:05.403006: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:185] None of the MLIR Optimization Passes are enabled (registered 2)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "104/104 [==============================] - 147s 1s/step - loss: 2.0223 - accuracy: 0.2782 - val_loss: 1.9164 - val_accuracy: 0.2838\n",
      "Epoch 2/10\n",
      "104/104 [==============================] - 128s 1s/step - loss: 1.7933 - accuracy: 0.3424 - val_loss: 1.5596 - val_accuracy: 0.4000\n",
      "Epoch 3/10\n",
      "104/104 [==============================] - 116s 1s/step - loss: 1.6866 - accuracy: 0.3679 - val_loss: 1.5518 - val_accuracy: 0.4027\n",
      "Epoch 4/10\n",
      "104/104 [==============================] - 128s 1s/step - loss: 1.6683 - accuracy: 0.3852 - val_loss: 1.4976 - val_accuracy: 0.4730\n",
      "Epoch 5/10\n",
      "104/104 [==============================] - 126s 1s/step - loss: 1.5933 - accuracy: 0.4042 - val_loss: 1.4229 - val_accuracy: 0.4730\n",
      "Epoch 6/10\n",
      "104/104 [==============================] - 121s 1s/step - loss: 1.5582 - accuracy: 0.4191 - val_loss: 1.4357 - val_accuracy: 0.4486\n",
      "Epoch 7/10\n",
      "104/104 [==============================] - 123s 1s/step - loss: 1.5204 - accuracy: 0.4242 - val_loss: 1.5338 - val_accuracy: 0.4351\n",
      "Epoch 8/10\n",
      "104/104 [==============================] - 120s 1s/step - loss: 1.4717 - accuracy: 0.4461 - val_loss: 1.5704 - val_accuracy: 0.4432\n",
      "Epoch 9/10\n",
      "104/104 [==============================] - 125s 1s/step - loss: 1.4502 - accuracy: 0.4682 - val_loss: 1.4473 - val_accuracy: 0.4514\n",
      "Epoch 10/10\n",
      "104/104 [==============================] - 124s 1s/step - loss: 1.4258 - accuracy: 0.4806 - val_loss: 1.4717 - val_accuracy: 0.4649\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = train_and_evaluate(dropout_prob=0.4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Congrats! You've completed the lab!"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [
    "5UOm2etrwYCs",
    "BtsR1Fzbh4ff",
    "GPCx8a-IZpUd",
    "X9U0ob6HLUAX"
   ],
   "name": "02b_neural_network.ipynb",
   "provenance": [],
   "toc_visible": true
  },
  "environment": {
   "kernel": "python3",
   "name": "tf2-gpu.2-6.m84",
   "type": "gcloud",
   "uri": "gcr.io/deeplearning-platform-release/tf2-gpu.2-6:m84"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
